//
//  Controller.cpp
//  C3W_Demo_By_Fan
//
//  Created by 范静涛 on 2024/7/22.
//

//------------------------------------------------------------------------------
//【文件名】Controller.cpp
//【功能模块和目的】控制器类实现
//【开发者及日期】范静涛 2024/7/22
//【更改记录】2024/8/9 范静涛 修改所有控制器公开成员函数返回值对应字符串标识符为RES_STR
//------------------------------------------------------------------------------

//自身类头文件
#include "Controller.hpp"
//size_t所属头文件
#include <cstddef>
//Model3D类所属头文件
#include "Model3D.hpp"
//size_t所属头文件
#include <cstddef>
//Point3D类所属头文件
#include "Point3D.hpp"
//Face3D类所属头文件
#include "Face3D.hpp"
//Line3D类所属头文件
#include "Line3D.hpp"
//std::vector所属头文件
#include <vector>
//std::shared_ptr所属头文件
#include <memory>
//std::string所属头文件
#include <string>
//Model3D_obj_Importer所属头文件
#include "Model3D_obj_Importer.hpp"
//Model3D_obj_Exporter所属头文件
#include "Model3D_obj_Exporter.hpp"

//------------------------------------------------------------------------------
//私有 静态数据成员
//------------------------------------------------------------------------------
//控制器实例指针
std::shared_ptr<Controller> Controller::m_pControllerIntance{nullptr};

//--------------------------------------------------------------------------
//静态Getter数据成员
//--------------------------------------------------------------------------
//所有控制器公开成员函数返回值，对应的字符串
const std::string Controller::RES_STR[] {
    "OK",
    "MODEL_INDEX_ERROR",
    "FACE_INDEX_ERROR",
    "LINE_INDEX_ERROR",
    "POINT_INDEX_ERROR",
    "IMPORTER_INDEX_ERROR",
    "EXPORTER_INDEX_ERROR",
    "FILE_TYPE_ERROR",
    "FILE_OPEN_ERROR",
    "DUPLICATE_FACE_IN_MODEL_ERROR",
    "DUPLICATE_LINE_IN_MODEL_ERROR",
    "DUPLICATE_POINT_IN_FACE_ERROR",
    "DUPLICATE_POINT_IN_LINE_ERROR",
    "DUPLICATE_IMPORTER_ERROR",
    "DUPLICATE_EXPORTER_ERROR",
    "UNKNOWN_ERROR"
};

//------------------------------------------------------------------------------
//非静态Setter成员函数
//------------------------------------------------------------------------------

//模型相关非静态Setter成员函数

//函数名：CreateAndSetToCurrent
//功能：创建空模型并指定为当前模型
//入口参数：无
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::CreateAndSetToCurrent(){
    //添加新模型到模型类列表
    m_Models.push_back(std::shared_ptr<Model3D>(new Model3D()));
    //指定当前模型
    m_CurrentModelIndex = m_Models.size() - 1;
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：SeleteCurrentModel
//功能：指定模型设为当前模型
//入口参数：size_t ModelIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::SeleteCurrentModel(size_t ModelIndex){
    //越界出错
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //设定当前模型
    m_CurrentModelIndex = ModelIndex;
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：RemoveModel
//功能：删除指定模型
//入口参数：size_t ModelIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::RemoveModel(size_t ModelIndex){
    //越界出错
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //删除模型
    m_Models.erase(m_Models.begin() + ModelIndex);
    //如无模型，更新当前模型
    if (m_Models.size() == 0) {
        m_CurrentModelIndex = SIZE_T_MAX;
    }
    //如删除当前模型，则当前模型更新为0号模型
    else if (ModelIndex == m_CurrentModelIndex) {
        m_CurrentModelIndex = 0;
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ImportModel
//功能：导入指定文件到指定模型
//入口参数：std::string FileName, size_t ModelIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ImportModel
(const std::string& FileName, size_t ModelIndex){
    //越界出错
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    try {
        //找可用导入器
        std::shared_ptr<Model3D_Importer> pImporter 
            = Model3D_Importer::GetIstanceByFileName(FileName);
        //执行导入
        (*m_Models[ModelIndex]) = pImporter->LoadFromFile(FileName);
    }
    //文件类型错误，或没有指定类型导入器
    catch (const Model3D_Importer::INVALID_FILE_TYPE& e) {
        return RES::FILE_TYPE_ERROR;
    }
    //文件打开错误
    catch (const Model3D_Importer::FILE_OPEN_FAIL& e) {
        return RES::FILE_OPEN_ERROR;
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ExportModel
//功能：导出指定模型到指定文件
//入口参数：
//出口参数：
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ExportModel
(const std::string& FileName, size_t ModelIndex){
    //越界出错
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    try {
        //找可用导出器
        std::shared_ptr<Model3D_Exporter> pExporter
            = Model3D_Exporter::GetIstanceByFileName(FileName);
        //执行导入
        pExporter->SaveToFile(FileName, (*m_Models[ModelIndex]));
    }
    //文件类型错误，或没有指定类型导出器
    catch (const Model3D_Exporter::INVALID_FILE_TYPE& e) {
        return RES::FILE_TYPE_ERROR;
    }
    //文件打开错误
    catch (const Model3D_Exporter::FILE_OPEN_FAIL& e) {
        return RES::FILE_OPEN_ERROR;
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ImportCurrentModel
//功能：导入指定文件到当前模型
//入口参数：const std::string& FileName
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ImportCurrentModel(const std::string& FileName){
    return ImportModel(FileName, m_CurrentModelIndex);
}
//------------------------------------------------------------------------------

//函数名：ExportCurrentModel
//功能：导出当前模型到指定文件
//入口参数：const std::string& FileName
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ExportCurrentModel(const std::string& FileName){
    return ExportModel(FileName, m_CurrentModelIndex);
}
//------------------------------------------------------------------------------

//面相关非静态Setter成员函数

//函数名：RemoveFaceFromModel
//功能：删除指定模型的指定面
//入口参数：size_t ModelIndex, size_t FaceIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::RemoveFaceFromModel
(size_t ModelIndex, size_t FaceIndex){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //越界错误
    if (FaceIndex >= m_Models[ModelIndex]->FaceCount) {
        return RES::FACE_INDEX_ERROR;
    }
    //删除
    Face3D Temp = *(m_Models[ModelIndex]->Faces[FaceIndex]);
    m_Models[ModelIndex]->RemoveFace(Temp);
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：RemoveFaceFromCurrentModel
//功能：删除当前模型的指定面
//入口参数：size_t FaceIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::RemoveFaceFromCurrentModel(size_t FaceIndex){
    return RemoveFaceFromModel(m_CurrentModelIndex, FaceIndex);
}
//------------------------------------------------------------------------------

//函数名：AppendFaceToModel
//功能：添加指定面到指定模型
//入口参数：size_t ModelIndex, const Face3D& AFace
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::AppendFaceToModel
(size_t ModelIndex, const Face3D& AFace){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //添加成功
    if (m_Models[ModelIndex]->AppendFace(AFace)) {
        return RES::OK;
    }
    //重复添加，导致失败
    else{
        return RES::DUPLICATE_FACE_IN_MODEL_ERROR;
    }
}
//------------------------------------------------------------------------------

//函数名：AppendFaceToCurrentModel
//功能：添加指定面到当前模型
//入口参数：const Face3D& AFace
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::AppendFaceToCurrentModel(const Face3D& AFace){
    return AppendFaceToModel(m_CurrentModelIndex, AFace);
}
//------------------------------------------------------------------------------

//线相关非静态Setter成员函数

//函数名：RemoveLineFromModel
//功能：删除指定模型指定线
//入口参数：size_t ModelIndex, size_t LineIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::RemoveLineFromModel
(size_t ModelIndex, size_t LineIndex){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //越界错误
    if (LineIndex >= m_Models[ModelIndex]->LineCount) {
        return RES::LINE_INDEX_ERROR;
    }
    //删除
    Line3D Temp = *(m_Models[ModelIndex]->Lines[LineIndex]);
    m_Models[ModelIndex]->RemoveLine(Temp);
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：RemoveLineFromCurrentModel
//功能：删除当前模型指定线
//入口参数：size_t LineIndex
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::RemoveLineFromCurrentModel(size_t LineIndex){
    return RemoveLineFromModel(m_CurrentModelIndex, LineIndex);
}
//------------------------------------------------------------------------------

//函数名：AppendLineToModel
//功能：添加指定线到指定模型
//入口参数：size_t ModelIndex, const Line3D& ALine
//出口参数：
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::AppendLineToModel
(size_t ModelIndex, const Line3D& ALine){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //添加成功
    if (m_Models[ModelIndex]->AppendLine(ALine)) {
        return RES::OK;
    }
    //添加重复线，导致失败
    else{
        return RES::DUPLICATE_LINE_IN_MODEL_ERROR;
    }
}
//------------------------------------------------------------------------------

//函数名：AppendLineToCurrentModel
//功能：添加指定线到当前模型
//入口参数：const Line3D& ALine
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::AppendLineToCurrentModel(const Line3D& ALine){
    return AppendLineToModel(m_CurrentModelIndex, ALine);
}
//------------------------------------------------------------------------------

//线相关非静态Setter成员函数

//函数名：ModifyPointInFaceOfModel
//功能：修改指定模型指定面上的指定点
//入口参数：size_t ModelIndex,
//        size_t FaceIndex,
//        size_t PointIndex,
//        const Point3D& APoint
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ModifyPointInFaceOfModel
(size_t ModelIndex, size_t FaceIndex, size_t PointIndex, const Point3D& APoint){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //越界错误
    if (FaceIndex >= m_Models[ModelIndex]->FaceCount) {
        return RES::FACE_INDEX_ERROR;
    }
    //越界错误
    if (PointIndex >= m_Models[ModelIndex]->Faces[FaceIndex]->PointCount) {
        return RES::POINT_INDEX_ERROR;
    }
    //执行修改
    try {
        m_Models[ModelIndex]->Faces[FaceIndex]->ModifyPoint(
            m_Models[ModelIndex]->Faces[FaceIndex]->Points[PointIndex],
            APoint);
    }
    //修改为重复点，导致错误
    catch (Point3DSet::DUPLICATE_ELEMENT) {
        return RES::DUPLICATE_POINT_IN_FACE_ERROR;
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ModifyPointInFaceOfCurrentModel
//功能：修改当前模型指定面上的指定点
//入口参数：size_t FaceIndex, size_t PointIndex, const Point3D& APoint
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ModifyPointInFaceOfCurrentModel
(size_t FaceIndex, size_t PointIndex, const Point3D& APoint){
    return ModifyPointInFaceOfModel(
        m_CurrentModelIndex,
        FaceIndex,
        PointIndex,
        APoint);
}
//------------------------------------------------------------------------------

//函数名：ModifyPointInLineOfModel
//功能：修改指定模型指定线上的指定点
//入口参数：size_t ModelIndex,
//        size_t LineIndex,
//        size_t PointIndex,
//        const Point3D& APoint
//出口参数：无
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ModifyPointInLineOfModel
(size_t ModelIndex, size_t LineIndex, size_t PointIndex, const Point3D& APoint){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //越界错误
    if (LineIndex >= m_Models[ModelIndex]->LineCount) {
        return RES::FACE_INDEX_ERROR;
    }
    //越界错误
    if (PointIndex >= m_Models[ModelIndex]->Lines[LineIndex]->PointCount) {
        return RES::POINT_INDEX_ERROR;
    }
    //修改
    try {
        m_Models[ModelIndex]->Lines[LineIndex]->ModifyPoint(
            m_Models[ModelIndex]->Lines[LineIndex]->Points[PointIndex], APoint);
    }
    //修改为重复点，导致错误
    catch (Point3DSet::DUPLICATE_ELEMENT) {
        return RES::DUPLICATE_POINT_IN_LINE_ERROR;
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ModifyPointInLineOfCurrentModel
//功能：修改当前模型指定线上的指定点
//入口参数：size_t LineIndex,
//        size_t PointIndex,
//        const Point3D& APoint
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ModifyPointInLineOfCurrentModel
(size_t LineIndex, size_t PointIndex, const Point3D& APoint){
    return ModifyPointInLineOfModel(
        m_CurrentModelIndex,
        LineIndex,
        PointIndex,
        APoint);
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//静态Setter/Getter共用成员函数
//------------------------------------------------------------------------------

//函数名：GetInstance
//功能：获取控制器实例指针，没有实例，则自动构造实例，返回指针
//入口参数：无
//出口参数：无
//返回值：控制器实例指针
std::shared_ptr<Controller> Controller::GetInstance(){
    if (m_pControllerIntance == nullptr) {
        m_pControllerIntance = std::shared_ptr<Controller>(new Controller());
    }
    return m_pControllerIntance;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//非静态Getter成员函数：需检查所有Getter是否有后置const
//------------------------------------------------------------------------------

//模型相关非静态Getter成员函数

//函数名：ListModels
//功能：列出所有模型信息
//入口参数：ModelInfoList& InfoList，会被清空重写
//出口参数：ModelInfoList& InfoList，会被清空重写
//返回值：RES::OK
Controller::RES Controller::ListModels(ModelInfoList& InfoList){
    //清空
    InfoList.clear();
    //逐一生成写入
    for (auto M : m_Models) {
        InfoList.push_back(ModelInfo{
            M->Name,
            M->FaceCount,
            M->Area,
            M->LineCount,
            M->Length,
            M->FaceCount * 3 + M->LineCount * 2,
            M->BoundBox_Vol});
    }
    return RES::OK;

}
//------------------------------------------------------------------------------

//函数名：ListModle
//功能：列出指定模型信息
//入口参数：size_t ModelIndex, ModelInfo& Info
//出口参数：ModelInfo& Info
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListModle(size_t ModelIndex, ModelInfo& Info){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //生成信息
    Info = ModelInfo{
        m_Models[ModelIndex]->Name,
        m_Models[ModelIndex]->FaceCount,
        m_Models[ModelIndex]->Area,
        m_Models[ModelIndex]->LineCount,
        m_Models[ModelIndex]->Length,
        m_Models[ModelIndex]->FaceCount * 3 
            + m_Models[ModelIndex]->LineCount * 2,
        m_Models[ModelIndex]->BoundBox_Vol
    };
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ListCurrentModel
//功能：列出当前模型信息
//入口参数：ModelInfo& Info
//出口参数：ModelInfo& Info
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListCurrentModel(ModelInfo& Info){
    return ListModle(m_CurrentModelIndex, Info);
}
//------------------------------------------------------------------------------

//面相关非静态Getter成员函数

//函数名：ListFacesInModel
//功能：列出指定模型的所有面信息
//入口参数：size_t ModelIndex, FaceInfoList& InfoList(会被清空重写)
//出口参数：FaceInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListFacesInModel(size_t ModelIndex, FaceInfoList& InfoList){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //清空
    InfoList.clear();
    //逐一生成写入
    for (auto pFace : m_Models[ModelIndex]->Faces) {
        FaceInfo Temp;
        for (size_t i = 0; i < 3; i++) {
            Temp.PointsInfo[i].X = pFace->Points[i].X;
            Temp.PointsInfo[i].Y = pFace->Points[i].Y;
            Temp.PointsInfo[i].Z = pFace->Points[i].Z;
        }
        Temp.Area = pFace->Area();
        InfoList.push_back(Temp);
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ListFacesInCurrentModel
//功能：列出当前模型中的所有面信息
//入口参数：FaceInfoList& InfoList(会被清空重写)
//出口参数：FaceInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListFacesInCurrentModel(FaceInfoList& InfoList){
    return ListFacesInModel(m_CurrentModelIndex, InfoList);
}
//------------------------------------------------------------------------------

//线相关非静态Getter成员函数

//函数名：ListLinesInModel
//功能：列出指定模型中所有线信息
//入口参数：size_t ModelIndex, LineInfoList& InfoList(会被清空重写)
//出口参数：LineInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListLinesInModel(size_t ModelIndex, LineInfoList& InfoList){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //清空
    InfoList.clear();
    //逐一生成写入
    for (auto pL : m_Models[ModelIndex]->Lines) {
        LineInfo Temp;
        for (size_t i = 0; i < 2; i++) {
            Temp.PointsInfo[i].X = pL->Points[i].X;
            Temp.PointsInfo[i].Y = pL->Points[i].Y;
            Temp.PointsInfo[i].Z = pL->Points[i].Z;
        }
        Temp.Length = pL->Length();
        InfoList.push_back(Temp);
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ListLinesInCurrentModel
//功能：列出当前模型中所有线信息
//入口参数：LineInfoList& InfoList(会被清空重写)
//出口参数：LineInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListLinesInCurrentModel(LineInfoList& InfoList){
    return ListLinesInModel(m_CurrentModelIndex, InfoList);
}
//------------------------------------------------------------------------------

//点相关非静态Getter成员函数

//函数名：ListPointsInFaceOfModel：
//功能：列出指定模型指定面中所有点信息
//入口参数：size_t ModelIndex, 
//        size_t FaceIndex,
//        PointInfoList& InfoList(会被清空重写)
//出口参数：PointInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListPointsInFaceOfModel
(size_t ModelIndex, size_t FaceIndex, PointInfoList& InfoList){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //越界错误
    if (FaceIndex >= m_Models[ModelIndex]->FaceCount) {
        return RES::FACE_INDEX_ERROR;
    }
    //清空
    InfoList.clear();
    //逐一生成写入
    for (size_t i = 0; i < 3; i++) {
        InfoList.push_back(
            PointInfo{
                m_Models[ModelIndex]->Faces[FaceIndex]->Points[i].X,
                m_Models[ModelIndex]->Faces[FaceIndex]->Points[i].Y,
                m_Models[ModelIndex]->Faces[FaceIndex]->Points[i].Z
            }
        );
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ListPointsInFaceOfCurrentModel
//功能：列出当前模型指定面中的所有点信息
//入口参数：size_t FaceIndex, PointInfoList& InfoList(会被清空重写)
//出口参数：PointInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListPointsInFaceOfCurrentModel
 (size_t FaceIndex, PointInfoList& InfoList){
    return ListPointsInFaceOfModel(m_CurrentModelIndex, FaceIndex, InfoList);
}
//------------------------------------------------------------------------------

//函数名：ListPointsInLineOfModel
//功能：列出指定模型指定线中所有点信息
//入口参数：size_t ModelIndex,
//        size_t LineIndex,
//        PointInfoList& InfoList(会被清空重写)
//出口参数：PointInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES Controller::ListPointsInLineOfModel
(size_t ModelIndex, size_t LineIndex, PointInfoList& InfoList){
    //越界错误
    if (ModelIndex >= m_Models.size()) {
        return RES::MODEL_INDEX_ERROR;
    }
    //越界错误
    if (LineIndex >= m_Models[ModelIndex]->LineCount) {
        return RES::LINE_INDEX_ERROR;
    }
    //清空
    InfoList.clear();
    //逐一生成写入
    for (size_t i = 0; i < 2; i++) {
        InfoList.push_back(
            PointInfo{
                m_Models[ModelIndex]->Lines[LineIndex]->Points[i].X,
                m_Models[ModelIndex]->Lines[LineIndex]->Points[i].Y,
                m_Models[ModelIndex]->Lines[LineIndex]->Points[i].Z
            }
        );
    }
    return RES::OK;
}
//------------------------------------------------------------------------------

//函数名：ListPointsInLineOfCurrentModel
//功能：列出当前模型指定线中所有点信息
//入口参数：size_t LineIndex, PointInfoList& InfoList(会被清空重写)
//出口参数：PointInfoList& InfoList(会被清空重写)
//返回值：执行结果枚举值，不为RES::OK，则为出现错误
Controller::RES  Controller::ListPointsInLineOfCurrentModel
(size_t LineIndex, PointInfoList& InfoList){
    return ListPointsInLineOfModel(m_CurrentModelIndex, LineIndex, InfoList);
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//私有 必要的构造、析构、赋值行为
//------------------------------------------------------------------------------

//函数名：Controller
//功能：构造函数，需要注册所有导入器、导出器
//入口参数：无
//出口参数：无
//返回值：无
Controller::Controller(){
    //注册obj导入器类
    Model3D_Importer::Register<Model3D_obj_Importer>();
    //注册obj导出器类
    Model3D_Exporter::Register<Model3D_obj_Exporter>();
    //导出时，压缩模型中的重复点
    Model3D_obj_Exporter::IsCompressedPoints = true;
}
//------------------------------------------------------------------------------
